home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / zcontext.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-27  |  19.9 KB  |  731 lines
  1. /* Copyright (C) 1991, 1995, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zcontext.c */
  20. /* Display PostScript context operators */
  21. #include "memory_.h"
  22. #include "ghost.h"
  23. #include "gp.h"            /* for usertime */
  24. #include "errors.h"
  25. #include "oper.h"
  26. #include "gsexit.h"
  27. #include "gsstruct.h"
  28. #include "gsutil.h"
  29. #include "gxalloc.h"
  30. #include "idict.h"
  31. #include "igstate.h"
  32. #include "icontext.h"
  33. #include "istruct.h"
  34. #include "dstack.h"
  35. #include "estack.h"
  36. #include "ostack.h"
  37. #include "store.h"
  38.  
  39. /****** THIS FILE IS NOT IN GOOD ENOUGH SHAPE TO USE YET. ******/
  40. /****** DON'T TRY TO USE IT.  REALLY. ******/
  41. /* Still needs:
  42.    fork: copy gstate stack
  43.    fork_done: do all necessary restores
  44.  */
  45.  
  46. /* Scheduling hooks in interp.c */
  47. extern int (*gs_interp_reschedule_proc)(P0());
  48. extern int (*gs_interp_time_slice_proc)(P0());
  49. extern int gs_interp_time_slice_ticks;
  50.  
  51. /* Per-context state stored in statics */
  52. extern ref ref_binary_object_format;
  53.  
  54. /* Context state structure */
  55. /* (defined in icontext.h) */
  56. extern_st(st_ref_stack);
  57. private_st_context_state();
  58. #define pcst ((gs_context_state_t *)vptr)
  59. private ENUM_PTRS_BEGIN(context_state_enum_ptrs) {
  60.     gs_ptr_type_t ret;
  61.     index -= 1;
  62. #define next_comp(np, st, e)\
  63.   if ( index < np )\
  64.     { ret = (*st.enum_ptrs)(&pcst->e, sizeof(pcst->e), index, pep); goto rx; }\
  65.   index -= np
  66. #define last_comp(np, st, e)\
  67.   return (*st.enum_ptrs)(&pcst->e, sizeof(pcst->e), index, pep)
  68.     next_comp(st_ref_stack_num_ptrs, st_ref_stack, dstack);
  69.     next_comp(st_ref_stack_num_ptrs, st_ref_stack, estack);
  70.     last_comp(st_ref_stack_num_ptrs, st_ref_stack, ostack);
  71. #undef next_comp
  72. #undef last_comp
  73. rx:    if ( ret == 0 )
  74.     {    /* A component ran out of pointers early. */
  75.         /* Just return a null so we can keep going. */
  76.         *pep = 0;
  77.         return ptr_struct_type;
  78.     }
  79.     return ret;
  80.     }
  81.     ENUM_PTR(0, gs_context_state_t, pgs);
  82. ENUM_PTRS_END
  83. private RELOC_PTRS_BEGIN(context_state_reloc_ptrs) {
  84.     (*st_ref_stack.reloc_ptrs)(&pcst->dstack, sizeof(ref_stack), gcst);
  85.     (*st_ref_stack.reloc_ptrs)(&pcst->estack, sizeof(ref_stack), gcst);
  86.     (*st_ref_stack.reloc_ptrs)(&pcst->ostack, sizeof(ref_stack), gcst);
  87.     RELOC_PTR(gs_context_state_t, pgs);
  88. } RELOC_PTRS_END
  89. #undef pcst
  90.  
  91. /* Context structure */
  92. typedef enum {
  93.     cs_active,
  94.     cs_done
  95. } ctx_status;
  96. typedef struct gs_context_s gs_context;
  97. struct gs_context_s {
  98.     gs_context_state_t state;    /* (must be first for subclassing) */
  99.         /* Private state */
  100.     ctx_status status;
  101.     ulong index;
  102.     bool detach;            /* true if a detach has been */
  103.                     /* executed for this context */
  104.     gs_context *next;        /* next context with same status */
  105.                     /* (active, waiting on same lock, */
  106.                     /* waiting on same condition, */
  107.                     /* waiting to be destroyed) */
  108.     gs_context *joiner;        /* context waiting on a join */
  109.                     /* for this one */
  110.     gs_context *table_next;        /* hash table chain */
  111. };
  112. gs_private_st_suffix_add3(st_context, gs_context, "context",
  113.   context_enum_ptrs, context_reloc_ptrs, st_context_state,
  114.   next, joiner, table_next);
  115.  
  116. /* Context list structure */
  117. typedef struct ctx_list_s {
  118.     gs_context *head;
  119.     gs_context *tail;
  120. } ctx_list;
  121.  
  122. /* Condition structure */
  123. typedef struct gs_condition_s {
  124.     ctx_list waiting;    /* contexts waiting on this condition */
  125. } gs_condition;
  126. gs_private_st_ptrs2(st_condition, gs_condition, "conditiontype",
  127.   condition_enum_ptrs, condition_reloc_ptrs, waiting.head, waiting.tail);
  128.  
  129. /* Lock structure */
  130. typedef struct gs_lock_s {
  131.     ctx_list waiting;        /* contexts waiting for this lock, */
  132.                     /* must be first for subclassing */
  133.     gs_context *holder;        /* context holding the lock, if any */
  134. } gs_lock;
  135. gs_private_st_suffix_add1(st_lock, gs_lock, "locktype",
  136.   lock_enum_ptrs, lock_reloc_ptrs, st_condition, holder);
  137.  
  138. /* Global state */
  139. typedef struct gs_scheduler_s {
  140.   gs_context *current;
  141.   long usertime_initial;    /* usertime when current started running */
  142.   ctx_list active;
  143.   gs_context *dead;
  144. #define ctx_table_size 19
  145.   gs_context *table[ctx_table_size];
  146. } gs_scheduler_t;
  147. private gs_scheduler_t *gs_scheduler;
  148. #define ctx_current gs_scheduler->current
  149. #define ctx_active gs_scheduler->active
  150. #define ctx_dead gs_scheduler->dead
  151. #define ctx_table gs_scheduler->table
  152. private gs_gc_root_t gs_scheduler_root;
  153. /* Structure definition */
  154. gs_private_st_composite(st_scheduler, gs_scheduler_t, "gs_scheduler",
  155.   scheduler_enum_ptrs, scheduler_reloc_ptrs);
  156. private ENUM_PTRS_BEGIN(scheduler_enum_ptrs) {
  157.   index -= 4;
  158.   if ( index < ctx_table_size )
  159.     ENUM_RETURN_PTR(gs_scheduler_t, table[index]);
  160.   return 0;
  161. }
  162.   ENUM_PTR(0, gs_scheduler_t, current);
  163.   ENUM_PTR(1, gs_scheduler_t, active.head);
  164.   ENUM_PTR(2, gs_scheduler_t, active.tail);
  165.   ENUM_PTR(3, gs_scheduler_t, dead);
  166. ENUM_PTRS_END
  167. private RELOC_PTRS_BEGIN(scheduler_reloc_ptrs) {
  168.   RELOC_PTR(gs_scheduler_t, current);
  169.   RELOC_PTR(gs_scheduler_t, active.head);
  170.   RELOC_PTR(gs_scheduler_t, active.tail);
  171.   RELOC_PTR(gs_scheduler_t, dead);
  172.   { int i;
  173.     for ( i = 0; i < ctx_table_size; ++i )
  174.       RELOC_PTR(gs_scheduler_t, table[i]);
  175.   }
  176. } RELOC_PTRS_END
  177.  
  178. /* Forward references */
  179. private int context_create(P2(gs_context **, gs_ref_memory_t *));
  180. private long context_usertime(P0());
  181. #define context_load(psched, pctx)\
  182.   do {\
  183.     if ( (pctx)->state.keep_usertime )\
  184.       (psched)->usertime_initial = context_usertime();\
  185.     context_state_load(&(pctx)->state);\
  186.   } while (0)
  187. #define context_store(psched, pctx)\
  188.   do {\
  189.     context_state_store(&(pctx)->state);\
  190.     if ( (pctx)->state.keep_usertime )\
  191.       (pctx)->state.usertime_total +=\
  192.         context_usertime() - (psched)->usertime_initial;\
  193.   } while (0)
  194. private int context_param(P2(os_ptr, gs_context **));
  195. #define check_context(op, vpc)\
  196.   if ( (code = context_param(op, &vpc)) < 0 ) return code
  197. private void context_destroy(P1(gs_context *));
  198. private void stack_copy(P4(ref_stack *, const ref_stack *, uint, uint));
  199. private int lock_acquire(P1(os_ptr));
  200. private int lock_release(P1(ref *));
  201.  
  202. /* List manipulation macros */
  203. #define add_last(pl,pc)\
  204.   (((pl)->head == 0 ? ((pl)->head = pc) : ((pl)->tail->next = pc)),\
  205.    (pl)->tail = pc, (pc)->next = 0)
  206. #define add_last_all(pl,pcl)        /* pcl->head != 0 */\
  207.   (((pl)->head == 0 ? ((pl)->head = (pcl)->head) :\
  208.     ((pl)->tail->next = (pcl)->head)),\
  209.    (pl)->tail = (pcl)->tail, (pcl)->head = (pcl)->tail = 0)
  210.  
  211. /* ------ Initialization ------ */
  212.  
  213. private int ctx_reschedule(P0());
  214. private int ctx_time_slice(P0());
  215. private void
  216. zcontext_init(void)
  217. {    gs_ref_memory_t *imem = iimemory_global;
  218.  
  219.     gs_scheduler = gs_alloc_struct((gs_memory_t *)imem, gs_scheduler_t,
  220.                        &st_scheduler, "gs_scheduler");
  221.     gs_register_struct_root((gs_memory_t *)imem, &gs_scheduler_root,
  222.                 (void **)&gs_scheduler, "gs_scheduler");
  223.     ctx_current = 0;
  224.     ctx_active.head = ctx_active.tail = 0;
  225.     ctx_dead = 0;
  226.     memset(ctx_table, 0, sizeof(ctx_table));
  227.     /******
  228.      ****** THIS WILL CRASH THE GC IN ITS PRESENT FORM ******
  229.      ******/
  230.     /* Create an initial context. */
  231.     if ( context_create(&ctx_current, imem) < 0 )
  232.       { lprintf("Can't create initial context!");
  233.         gs_abort();
  234.       }
  235.     /* Hook into the interpreter. */
  236.     gs_interp_reschedule_proc = ctx_reschedule;
  237.     gs_interp_time_slice_proc = ctx_time_slice;
  238.     gs_interp_time_slice_ticks = 100;
  239. }
  240.  
  241. /* ------ Interpreter interface to scheduler ------ */
  242.  
  243. /* When an operator decides it is time to run a new context, */
  244. /* it returns o_reschedule.  The interpreter saves all its state in */
  245. /* memory, calls ctx_reschedule, and then loads the state from memory. */
  246. private int
  247. ctx_reschedule(void)
  248. {    /* Save the state of the current context in ctx_current, */
  249.     /* if any context is current at all. */
  250.     if ( ctx_current != 0 )
  251.       context_store(gs_scheduler, ctx_current);
  252.     /* If there are any dead contexts waiting to be released, */
  253.     /* take care of that now. */
  254.     while ( ctx_dead != 0 )
  255.       { gs_context *next = ctx_dead->next;
  256.  
  257.         context_destroy(ctx_dead);
  258.         ctx_dead = next;
  259.       }
  260.     /* Run the first ready context. */
  261.     if ( ctx_active.head == 0 )
  262.       { lprintf("No context to run!");
  263.         return_error(e_Fatal);
  264.       }
  265.     ctx_current = ctx_active.head;
  266.     if ( !(ctx_active.head = ctx_active.head->next) )
  267.       ctx_active.tail = 0;
  268.     /* Load the state of the new current context. */
  269.     context_load(gs_scheduler, ctx_current);
  270.     esfile_clear_cache();
  271.     dict_set_top();        /* reload dict stack cache */
  272.     return 0;
  273. }
  274.  
  275. /* If the interpreter wants to time-slice, it saves its state, */
  276. /* calls ctx_time_slice, and reloads its state. */
  277. private int
  278. ctx_time_slice(void)
  279. {    if ( ctx_active.head == 0 )
  280.       return 0;
  281.     add_last(&ctx_active, ctx_current);
  282.     return ctx_reschedule();
  283. }
  284.  
  285. /* ------ Context operators ------ */
  286.  
  287. private int fork_done(P1(os_ptr));
  288.  
  289. /* - currentcontext <context> */
  290. private int
  291. zcurrentcontext(register os_ptr op)
  292. {    push(1);
  293.     make_int(op, ctx_current->index);
  294.     return 0;
  295. }
  296.  
  297. /* <context> detach - */
  298. private int
  299. zdetach(register os_ptr op)
  300. {    gs_context *pctx;
  301.     int code;
  302.  
  303.     check_context(op, pctx);
  304.     if ( pctx->joiner != 0 || pctx->detach )
  305.       return_error(e_invalidcontext);
  306.     switch ( pctx->status )
  307.       {
  308.       case cs_active:
  309.         pctx->detach = true;
  310.         break;
  311.       case cs_done:
  312.         context_destroy(pctx);
  313.       }
  314.     pop(1);
  315.     return 0;
  316. }
  317.  
  318. /* <mark> <obj1> ... <objN> <proc> fork <context> */
  319. private int
  320. zfork(register os_ptr op)
  321. {    uint mcount = ref_stack_counttomark(&o_stack);
  322.     gs_context *pctx;
  323.     int code;
  324.  
  325.     check_proc(*op);
  326.     if ( mcount == 0 )
  327.       return_error(e_unmatchedmark);
  328.     if ( gs_imemory.save_level )
  329.       return_error(e_invalidcontext);
  330.     code = context_create(&pctx, iimemory_global);
  331.     if ( code < 0 )
  332.       return code;
  333.     /* Share local and global VM. */
  334.     pctx->state.memory = gs_imemory;
  335.     { int i;
  336.       for ( i = 0; i < countof(gs_imemory.spaces.indexed); ++i )
  337.         if ( gs_imemory.spaces.indexed[i] != 0 )
  338.           gs_imemory.spaces.indexed[i]->num_contexts++;
  339.     }
  340.     /* Initialize the stacks. */
  341.     { ref_stack *dstack = &pctx->state.dstack;
  342.       uint count = ref_stack_count(&d_stack);
  343.  
  344.       ref_stack_push(dstack, count - ref_stack_count(dstack));
  345.       stack_copy(dstack, &d_stack, count, 0);
  346.     }
  347.     { ref_stack *estack = &pctx->state.estack;
  348.  
  349.       ref_stack_push(estack, 3);
  350.       /* fork_done must be executed in both normal and error cases. */
  351.       make_mark_estack(estack->p - 2, es_other, fork_done);
  352.       make_oper(estack->p - 1, 0, fork_done);
  353.       *estack->p = *op;
  354.     }
  355.     { ref_stack *ostack = &pctx->state.ostack;
  356.       uint count = mcount - 2;
  357.  
  358.       ref_stack_push(ostack, count);
  359.       stack_copy(ostack, &o_stack, count, 1);
  360.     }
  361.     /****** COPY GSTATE STACK ******/
  362.     pctx->state.binary_object_format = ref_binary_object_format;
  363.     add_last(&ctx_active, pctx);
  364.     pop(mcount - 1);
  365.     op = osp;
  366.     make_int(op, pctx->index);
  367.     return 0;
  368. }
  369. /* This gets executed when a context terminates normally */
  370. /* or when the stack is being unwound for an error termination. */
  371. /****** MUST DO ALL RESTORES ******/
  372. /****** WHAT IF invalidrestore? ******/
  373. private int
  374. fork_done(os_ptr op)
  375. {    if ( ctx_current->detach )
  376.       { /*
  377.          * We can't free the context's memory yet, because the
  378.          * interpreter still has references to it.  Instead, queue the
  379.          * context to be freed the next time we reschedule.
  380.          */
  381.         context_store(gs_scheduler, ctx_current);
  382.         ctx_current->next = ctx_dead;
  383.         ctx_dead = ctx_current;
  384.         ctx_current = 0;
  385.       }
  386.     else
  387.       { gs_context *pctx = ctx_current->joiner;
  388.  
  389.         ctx_current->status = cs_done;
  390.         /* Schedule the context waiting to join this one, if any. */
  391.         if ( pctx != 0 )
  392.           add_last(&ctx_active, pctx);
  393.       }
  394.     return o_reschedule;
  395. }
  396.  
  397. /* <context> join <mark> <obj1> ... <objN> */
  398. private int
  399. zjoin(register os_ptr op)
  400. {    gs_context *pctx;
  401.     int code;
  402.  
  403.     check_context(op, pctx);
  404.     if ( pctx->joiner != 0 || pctx->detach || pctx == ctx_current ||
  405.          pctx->state.memory.space_global !=
  406.            ctx_current->state.memory.space_global ||
  407.          pctx->state.memory.space_local !=
  408.            ctx_current->state.memory.space_local ||
  409.          gs_imemory.save_level != 0
  410.        )
  411.       return_error(e_invalidcontext);
  412.     switch ( pctx->status )
  413.        {
  414.     case cs_active:
  415.         pctx->joiner = ctx_current;
  416.         return o_reschedule;
  417.     case cs_done:
  418.        {    const ref_stack *ostack = &pctx->state.ostack;
  419.         uint count = ref_stack_count(ostack);
  420.  
  421.         push(count);
  422.         { ref *rp = ref_stack_index(&o_stack, count);
  423.           make_mark(rp);
  424.         }
  425.         stack_copy(&o_stack, ostack, count, 0);
  426.         context_destroy(pctx);
  427.        }
  428.        }
  429.     return 0;
  430. }
  431.  
  432. /* - yield - */
  433. private int
  434. zyield(register os_ptr op)
  435. {    if ( ctx_active.head == 0 )
  436.       return 0;
  437.     add_last(&ctx_active, ctx_current);
  438.     return o_reschedule;
  439. }
  440.  
  441. /* ------ Condition and lock operators ------ */
  442.  
  443. private int
  444.   monitor_cleanup(P1(os_ptr)),
  445.   monitor_release(P1(os_ptr)),
  446.   await_lock(P1(os_ptr));
  447.  
  448. /* - condition <condition> */
  449. private int
  450. zcondition(register os_ptr op)
  451. {    gs_condition *pcond =
  452.       ialloc_struct(gs_condition, &st_condition, "zcondition");
  453.  
  454.     if ( pcond == 0 )
  455.       return_error(e_VMerror);
  456.     pcond->waiting.head = pcond->waiting.tail = 0;
  457.     push(1);
  458.     make_istruct(op, a_all, pcond);
  459.     return 0;
  460. }
  461.  
  462. /* - lock <lock> */
  463. private int
  464. zlock(register os_ptr op)
  465. {    gs_lock *plock = ialloc_struct(gs_lock, &st_lock, "zlock");
  466.  
  467.     if ( plock == 0 )
  468.       return_error(e_VMerror);
  469.     plock->holder = 0;
  470.     plock->waiting.head = plock->waiting.tail = 0;
  471.     push(1);
  472.     make_istruct(op, a_all, plock);
  473.     return 0;
  474. }
  475.  
  476. /* <lock> <proc> monitor - */
  477. private int
  478. zmonitor(register os_ptr op)
  479. {    gs_lock *plock;
  480.     int code;
  481.  
  482.     check_stype(op[-1], st_lock);
  483.     check_proc(*op);
  484.     plock = r_ptr(op - 1, gs_lock);
  485.     if ( plock->holder == ctx_current ||
  486.          (gs_imemory.save_level != 0 &&
  487.           plock->holder != 0 &&
  488.           plock->holder->state.memory.space_local ==
  489.             ctx_current->state.memory.space_local)
  490.        )
  491.       return_error(e_invalidcontext);
  492.     /*
  493.      * We push on the e-stack:
  494.      *    The lock object
  495.      *    An e-stack mark with monitor_cleanup, to release the lock
  496.      *      in case of an error
  497.      *    monitor_release, to release the lock in the normal case
  498.      *    The procedure to execute
  499.      */
  500.     check_estack(4);
  501.     code = lock_acquire(op - 1);
  502.     if ( code != 0 )
  503.       { /* We didn't acquire the lock.  Re-execute this later. */
  504.         push_op_estack(zmonitor);
  505.         return code;    /* o_reschedule */
  506.       }
  507.     *++esp = op[-1];
  508.     push_mark_estack(es_other, monitor_cleanup);
  509.     push_op_estack(monitor_release);
  510.     *++esp = *op;
  511.     pop(2);
  512.     return code;
  513. }
  514. /* Release the monitor lock when unwinding for an error or exit. */
  515. private int
  516. monitor_cleanup(os_ptr op)
  517. {    int code = lock_release(esp);
  518.     --esp;
  519.     return code;
  520. }
  521. /* Release the monitor lock when the procedure completes. */
  522. private int
  523. monitor_release(os_ptr op)
  524. {    --esp;
  525.     return monitor_cleanup(op);
  526. }
  527.  
  528. /* <condition> notify - */
  529. private int
  530. znotify(register os_ptr op)
  531. {    gs_condition *pcond;
  532.  
  533.     check_stype(*op, st_condition);
  534.     pcond = r_ptr(op, gs_condition);
  535.     pop(1); op--;
  536.     if ( pcond->waiting.head == 0 )        /* nothing to do */
  537.       return 0;
  538.     add_last_all(&ctx_active, &pcond->waiting);
  539.     return zyield(op);
  540. }
  541.  
  542. /* <lock> <condition> wait - */
  543. private int
  544. zwait(register os_ptr op)
  545. {    gs_lock *plock;
  546.     gs_condition *pcond;
  547.  
  548.     check_stype(op[-1], st_lock);
  549.     plock = r_ptr(op - 1, gs_lock);
  550.     check_stype(*op, st_condition);
  551.     pcond = r_ptr(op, gs_condition);
  552.     if ( plock->holder != ctx_current ||
  553.          (gs_imemory.save_level != 0 &&
  554.           (r_space(op - 1) == avm_local || r_space(op) == avm_local))
  555.        )
  556.       return_error(e_invalidcontext);
  557.     check_estack(1);
  558.     lock_release(op - 1);
  559.     add_last(&pcond->waiting, ctx_current);
  560.     push_op_estack(await_lock);
  561.     return o_reschedule;
  562. }
  563. /* When the condition is signaled, wait for acquiring the lock. */
  564. private int
  565. await_lock(os_ptr op)
  566. {    int code = lock_acquire(op - 1);
  567.  
  568.     if ( code == 0 )
  569.       { pop(2);
  570.         return code;
  571.       }
  572.     /* We didn't acquire the lock.  Re-execute the wait. */
  573.     push_op_estack(await_lock);
  574.     return code;        /* o_reschedule */
  575. }
  576.  
  577. /* ------ Miscellaneous operators ------ */
  578.  
  579. /* - usertime <int> */
  580. private int
  581. zusertime_context(register os_ptr op)
  582. {    long utime = context_usertime();
  583.  
  584.     push(1);
  585.     if ( !ctx_current->state.keep_usertime ) {
  586.       /*
  587.        * This is the first time this context has executed usertime:
  588.        * we must track its execution time from now on.
  589.        */
  590.       gs_scheduler->usertime_initial = utime;
  591.       ctx_current->state.keep_usertime = true;
  592.     }
  593.     make_int(op, ctx_current->state.usertime_total + utime -
  594.          gs_scheduler->usertime_initial);
  595.     return 0;
  596. }
  597.  
  598. /* ------ Internal routines ------ */
  599.  
  600. /* Create a context. */
  601. private int
  602. context_create(gs_context **ppctx, gs_ref_memory_t *mem)
  603. {    gs_context *pctx;
  604.     int code;
  605.     long ctx_index;
  606.     gs_context **pte;
  607.  
  608.     pctx = gs_alloc_struct((gs_memory_t *)mem, gs_context, &st_context,
  609.                    "context_create");
  610.     if ( pctx == 0 )
  611.       return_error(e_VMerror);
  612.     code = context_state_alloc(&pctx->state, mem);
  613.     if ( code < 0 )
  614.       { gs_free_object((gs_memory_t *)mem, pctx, "context_create");
  615.         return code;
  616.       }
  617.     ctx_index = gs_next_ids(1);
  618.     pctx->status = cs_active;
  619.     pctx->index = ctx_index;
  620.     pctx->detach = false;
  621.     pctx->next = 0;
  622.     pctx->joiner = 0;
  623.     pte = &ctx_table[ctx_index % ctx_table_size];
  624.     pctx->table_next = *pte;
  625.     *pte = pctx;
  626.     *ppctx = pctx;
  627.     return 0;
  628. }
  629.  
  630. /* Check a context ID.  Note that we do not check for context validity. */
  631. private int
  632. context_param(os_ptr op, gs_context **ppctx)
  633. {    gs_context *pctx;
  634.     long index;
  635.  
  636.     check_type(*op, t_integer);
  637.     index = op->value.intval;
  638.     if ( index < 0 )
  639.       return_error(e_invalidcontext);
  640.     pctx = ctx_table[index % ctx_table_size];
  641.     for ( ; ; pctx = pctx->table_next )
  642.       { if ( pctx == 0 )
  643.           return_error(e_invalidcontext);
  644.         if ( pctx->index == index )
  645.           break;
  646.       }
  647.     *ppctx = pctx;
  648.     return 0;
  649. }
  650.  
  651. /* Read the usertime as a single value. */
  652. private long
  653. context_usertime(void)
  654. {    long secs_ns[2];
  655.  
  656.     gp_get_usertime(secs_ns);
  657.     return secs_ns[0] * 1000 + secs_ns[1] / 1000000;
  658. }
  659.  
  660. /* Destroy a context. */
  661. private void
  662. context_destroy(gs_context *pctx)
  663. {    gs_context **ppctx = &ctx_table[pctx->index % ctx_table_size];
  664.  
  665.     while ( *ppctx != pctx )
  666.       ppctx = &(*ppctx)->table_next;
  667.     *ppctx = (*ppctx)->table_next;
  668.     context_state_free(&pctx->state, iimemory);
  669.     ifree_object(pctx, "context_destroy");
  670. }
  671.  
  672. /* Copy the top elements of one stack to another. */
  673. /* Note that this does not push the elements: */
  674. /* the destination stack must have enough space preallocated. */
  675. private void
  676. stack_copy(ref_stack *to, const ref_stack *from, uint count, uint from_index)
  677. {    long i;
  678.  
  679.     for ( i = (long)count - 1; i >= 0; --i )
  680.       *ref_stack_index(to, i) = *ref_stack_index(from, i + from_index);
  681. }
  682.  
  683. /* Acquire a lock.  Return 0 if acquired, o_reschedule if not. */
  684. private int
  685. lock_acquire(os_ptr op)
  686. {    gs_lock *plock = r_ptr(op, gs_lock);
  687.  
  688.     if ( plock->holder == 0 )
  689.       { plock->holder = ctx_current;
  690.         return 0;
  691.       }
  692.     add_last(&plock->waiting, ctx_current);
  693.     return o_reschedule;
  694. }
  695.  
  696. /* Release a lock.  Return 0 if OK, e_invalidcontext if not. */
  697. private int
  698. lock_release(ref *op)
  699. {    gs_lock *plock = r_ptr(op, gs_lock);
  700.  
  701.     if ( plock->holder == ctx_current )
  702.       { plock->holder = 0;
  703.         add_last_all(&ctx_active, &plock->waiting);
  704.         return 0;
  705.       }
  706.     return_error(e_invalidcontext);
  707. }
  708.  
  709. /* ------ Initialization procedure ------ */
  710.  
  711. BEGIN_OP_DEFS(zcontext_op_defs) {
  712.     {"0condition", zcondition},
  713.     {"0currentcontext", zcurrentcontext},
  714.     {"1detach", zdetach},
  715.     {"2fork", zfork},
  716.     {"1join", zjoin},
  717.     {"0lock", zlock},
  718.     {"2monitor", zmonitor},
  719.     {"1notify", znotify},
  720.     {"2wait", zwait},
  721.     {"0yield", zyield},
  722.         /* Note that the following replace prior definitions */
  723.         /* in the indicated files: */
  724.     {"0usertime", zusertime_context},    /* zmisc.c */
  725.         /* Internal operators */
  726.     {"0%fork_done", fork_done},
  727.     {"0%monitor_cleanup", monitor_cleanup},
  728.     {"0%monitor_release", monitor_release},
  729.     {"2%await_lock", await_lock},
  730. END_OP_DEFS(zcontext_init) }
  731.